/*
 * Powered By fanrenqij.com
 * Since 2017 - 2017
 */

package com.fanrenqiji.modules.business.eventcase.service.impl;

import com.fanrenqiji.entity.*;
import com.fanrenqiji.modules.business.course.dao.CourseDao;
import com.fanrenqiji.modules.business.event.dao.EventDao;
import org.hibernate.criterion.Order;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.collect.Lists;

import com.fanrenqiji.modules.business.eventcase.vo.EventCaseVO;
import com.fanrenqiji.modules.business.eventcase.dao.EventCaseDao;
import com.fanrenqiji.modules.business.eventcase.service.EventCaseService;

import org.dozer.DozerBeanMapper;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import com.fanrenqiji.common.persistence.Page;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.apache.commons.lang3.StringUtils;

import java.util.*;

/**
 * 课程事件实例表业务逻辑实现
 *
 * @author wentao
 */
@Service(value = "eventCase")
@Transactional(readOnly = true)
public class EventCaseServiceImpl implements EventCaseService{

@Autowired
private EventCaseDao eventCaseDao;
@Autowired
private CourseDao courseDao;
@Autowired
private EventDao eventDao;

@Autowired
DozerBeanMapper beanMapper;

/**
 * 插入
 *
 * @param eventCase
 * 插入的对象
 * @return 插入数据条数
 */
@Transactional
public EventCaseVO insert(EventCaseVO eventCase){
        EventCaseEntity eventCaseEntity=new EventCaseEntity();
        beanMapper.map(eventCase,eventCaseEntity);
        eventCaseDao.save(eventCaseEntity);
        beanMapper.map(eventCaseEntity,eventCase);
        return eventCase;
        }


/**
 * 批量插入
 *
 * @param list
 * 数据列表
 * @return 插入数据条数
 */
@Transactional
public void insertList(List<EventCaseVO>list){
        for(EventCaseVO eventCase:list){
        insert(eventCase);
        }
        }


/**
 * 修改
 *
 * @param eventCase
 *            修改的数据
 * @return 修改的数据
 */
@Transactional
public EventCaseVO update(EventCaseVO eventCase){
        EventCaseEntity eventCaseEntity=null;
        if(StringUtils.isNotEmpty(eventCase.getId())){
        eventCaseEntity=eventCaseDao.findOne(Long.parseLong(eventCase.getId()));
        }
        if(eventCaseEntity==null){
        eventCaseEntity=new EventCaseEntity();
        }
        beanMapper.map(eventCase,eventCaseEntity);
        eventCaseDao.save(eventCaseEntity);
        beanMapper.map(eventCaseEntity,eventCase);
        return eventCase;
        }


/**
 * 删除
 *
 * @param id
 *            数据标识
 * @return 删除的数据条数
 */
@Transactional
public void delete(String id){
        eventCaseDao.deleteById(Long.parseLong(id));
        }


/**
 * 查询所有数据
 *
 * @return 数据列表
 */
public List<EventCaseVO>getAll(){
        List<EventCaseVO>list=Lists.newArrayList();
        List<EventCaseEntity>entities=eventCaseDao.findAllList();
        for(EventCaseEntity eventCaseEntity:entities){
        EventCaseVO eventCaseVO=new EventCaseVO();
        beanMapper.map(eventCaseEntity,eventCaseVO);
        list.add(eventCaseVO);
        }
        return list;
        }


/**
 * 通过条件查询数据列表
 *
 * @param eventCase
 *            查询条件
 * @return 数据列表
 */
public List<EventCaseVO>getList(EventCaseVO eventCase){
        List<EventCaseVO>list=Lists.newArrayList();
        DetachedCriteria dc=eventCaseDao.createDetachedCriteria();
        dc.add(Restrictions.eq(EventCaseEntity.DEL_FLAG,EventCaseEntity.DEL_FLAG_NORMAL));
    /*
    dc.createAlias("eventCase", "eventCase"); // as

    dc.add(Restrictions.ne("id", 1L)); // !=

    if (StringUtils.isNotEmpty(eventCase.getName())) {
        dc.add(Restrictions.like("name", "%" + eventCase.getName() + "%")); //like
    }
    if (StringUtils.isNotEmpty(eventCase.getName())) {
        dc.add(Restrictions.eq("name", eventCase.getName())); //=
    }

	dc.addOrder(Order.asc("office.id")).addOrder(Order.asc("name"));  //排序

    */
        List<EventCaseEntity>entities=eventCaseDao.find(dc);
        for(EventCaseEntity eventCaseEntity:entities){
        EventCaseVO eventCaseVO=new EventCaseVO();
        beanMapper.map(eventCaseEntity,eventCaseVO);
        list.add(eventCaseVO);
        }
        return list;
        }


/**
 * 通过id查询数据
 *
 * @param id
 *            数据标识
 * @return 数据对象
 */
public EventCaseVO get(String id){
        EventCaseVO eventCase=new EventCaseVO();
        EventCaseEntity eventCaseEntity=eventCaseDao.findOne(Long.parseLong(id));
        if(eventCaseEntity==null){
        eventCaseEntity=new EventCaseEntity();
        }
        beanMapper.map(eventCaseEntity,eventCase);
        return eventCase;
        }


/**
 * 根据条件分页查询
 * @param page
 * @param eventCase
 * @return
 */
public Page<EventCaseVO>findEventCaseByPage(Page<EventCaseVO>page,EventCaseVO eventCase){
        Page<EventCaseEntity>pageEntity=new Page<EventCaseEntity>(page.getPageNo(),page.getPageSize());
        DetachedCriteria dc=eventCaseDao.createDetachedCriteria();
        dc.add(Restrictions.eq(EventCaseEntity.DEL_FLAG,EventCaseEntity.DEL_FLAG_NORMAL));
        if (StringUtils.isNotEmpty(eventCase.getId())) {
            dc.add(Restrictions.like("id", "%" + eventCase.getId() + "%")); //like
        }

        if(!StringUtils.isNotEmpty(page.getOrderBy())){
            dc.addOrder(Order.desc("id"));
        }
        pageEntity=eventCaseDao.find(pageEntity,dc);
        beanMapper.map(pageEntity,page);
        List<EventCaseVO>list=Lists.newArrayList();
        for(EventCaseEntity eventCaseEntity:pageEntity.getList()){
            EventCaseVO eventCaseVO=new EventCaseVO();
            beanMapper.map(eventCaseEntity,eventCaseVO);
            list.add(eventCaseVO);
        }
        page.setList(list);
        return page;
        }

        /**
         * 将事件保存到事件实例里面 同时保存到课程的集合里面（作业）
         * @param courseid
         * @param eventid
         */
        @Transactional
public void saveevent(String courseid,String eventid){
        // 先将对象查询出来 传递过来的是 事件 和课程 需要操作中间表
                CourseEntity courseEntity = null;// 课程实体
                EventEntity eventEntity = null;// 事件实体
                if(StringUtils.isNotBlank(courseid)){
                      courseEntity = courseDao.findOne(Long.parseLong(courseid));
                }
                //事件实体
                if(StringUtils.isNotBlank(eventid)){
                       eventEntity = eventDao.findOne(Long.parseLong(eventid));
                }
         /*   eventEntity.setCourse(courseEntity);*/
            eventDao.save(eventEntity);
        }

        /**
         * 将事件实例从课程集合中删除
          * @param courseid
         * @param eventcaseid
         */
@Transactional
public  void removeeventcase(String courseid ,String eventcaseid){
        // 还是先要将对象查询出来
        CourseEntity courseEntity = null;
        EventCaseEntity eventCaseEntity=null;
        if(StringUtils.isNotBlank(courseid)){
               courseEntity = courseDao.findOne(Long.parseLong(courseid));
        }
        if(StringUtils.isNotBlank(eventcaseid)){
             eventCaseEntity = eventCaseDao.findOne(Long.parseLong(eventcaseid));
        }
        // 对集合进行操作 最后记得update一下
        //先要新建一个集合
        List<EventCaseEntity> eventCaseEntities = new ArrayList<EventCaseEntity>();
        // 将原有的集合去出来
        List<EventCaseEntity> eventCases = courseEntity.getEventCases();
        //先将查询出来的元素进行删除
        eventCases.remove(eventCaseEntity);
        //重新赋值eventCases
        for (EventCaseEntity eventCaseEntity1:eventCases
             ) {
                if(eventCaseEntity1.equals(eventCaseEntity)) continue;
                eventCaseEntities.add(eventCaseEntity1);
        }
        // 赋值 保存
        courseEntity.setEventCases(eventCaseEntities);
        courseDao.save(courseEntity);
}

    /**
     * 向事件实例中添加或者修改 问题的方法
     * @param courseid
     * @param eventcaseid
     * @param questionid
     */
    @Transactional
public void addquestion(String courseid,String eventcaseid,String questionid){
    //老规矩 先要将 传过来的id 查询出来  其实不用课程的id
        EventCaseEntity eventCaseEntity = null;

        if(StringUtils.isNotBlank(eventcaseid)){
            eventCaseEntity = eventCaseDao.findOne(Long.parseLong(eventcaseid));
        }


            // 进行保存
            eventCaseDao.save(eventCaseEntity);
}

    /**
     * 修改事件实例中间表的方法
     * @param id
     * @param shijian
     */
    @Transactional
    public void updatacourseitemevent(String id,String shijian){
        // 先要将对象查询出来

    }

    /**
     * 课程组里面添加事件实例的方法
     * @param coursegroupid
     * @param eventid
     */
    @Transactional
    public void coursegroupandevent(String coursegroupid,String eventid){
            // 主要是在课程组里面进行设置事件实例的id
            //先要将课程组查询出来

    }

    /**
     * 从课程组里面删除事件实例的方法
     *
     * @param coursegroupid
     * @param eventcaseid
     */
    @Transactional
    public void removeeventcase2(String coursegroupid,String eventcaseid) {
        // 先将课程组查询出来

    }



    /**
     * 根据事件实例中间表来进行查询数据
     * @param id
     * @return
     */
    public EventCaseVO selectByCourseItemEventId(String id){
        return  null;
    }
}
